home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 1 / QRZ Ham Radio Callsign Database - December 1993.iso / ucsd / packet / thebox / sourcarc.exe / arc / LOG.C < prev    next >
Encoding:
C/C++ Source or Header  |  1988-09-12  |  18.9 KB  |  764 lines
  1. # include "Boxdefs.h"
  2. # include "memory.ex"
  3.  
  4. login(Channel)
  5. /*------------------------------------------------------------------------*/
  6. /* Funktion : Macht einen Logeintrag mit offener Endezeit (??:??)         */
  7. /*            Inititalisiert diverse Paramter des entsprechenden          */
  8. /*            logischen Kanals.                                           */
  9. /* Uebergabe: Pointer auf logische Kanalstruktur                          */
  10. /* Retour   : nichts                                                      */
  11. /*------------------------------------------------------------------------*/
  12. struct header *Channel;
  13. {
  14.  file LogChannel;
  15.  unsigned long time_();
  16.  long tell_();
  17.  char ChanStr[80];
  18.  char LgStr[260];
  19.  char DatumUhrzeit[25];
  20.  unsigned char meldung[81];
  21.  int  i;
  22.  int neu;
  23.  int chan;
  24.  unsigned char *uc;
  25.  unsigned char *charptr;
  26.  char dummy[256] , *cc;
  27.  char mybbs[20];
  28.  
  29.  uc = Channel->Response;
  30.  uc += 17;
  31.                                                 /* Call holen             */
  32.  sprintf(Channel->call,"%s",uc);
  33.  i = 0;                                         /* SSID abschneiden       */
  34.  while(isalnum(*(Channel->call + i))) i++;
  35.  *(Channel->call + i) = '\0';
  36.  
  37.  uhrzeitlesen(&DatumUhrzeit);                   /* Uhrzeit lesen          */
  38.  
  39.  neu = 0;
  40.  
  41.  if(isCall(Channel->call))
  42.  {
  43.   _setmem(mybbs,7,0);
  44.   neu = findUser(Channel,&DatumUhrzeit,&mybbs);
  45.  
  46.   if(Channel->SFChannel == 2) clearAmtor(Channel->RS232);
  47.  
  48.  }
  49.  
  50.  if ( ((isCall(Channel->call)==1)&&(isBlack(Channel)==0))
  51.     ||(Channel->Mailbox == 0) || (Channel->SFFlag != Off)
  52.     )
  53.  {
  54.   Channel->ErrorCount = 0;
  55.   uc = Channel->Response;
  56.   uc += 17;
  57.   while(!isspace(*uc)) uc++;                    /* Call ausblenden        */
  58.   while( isspace(*uc)) uc++;                    /* Spaces ausblenden      */
  59.  
  60.   sprintf(LgStr,"%s",uc);                       /* Via ....               */
  61.  
  62.   *(LgStr + strlen(LgStr) -1 ) = '\0';          /* CR loeschen            */
  63.  
  64.   if(Channel->actual == 1)                      /* Wenn angezeigt         */
  65.   gotoxy(41,6);                                 /* ausgeben               */
  66.  
  67.   sprintf(meldung,"%s",Channel->Response+4);
  68.  
  69.   *(meldung + strlen(meldung) - 1 ) = '\0';     /* Cr loeschen            */
  70.  
  71.   uc = meldung;
  72.   charptr = Channel->VRAM + 440;
  73.   for(i=0;i<strlen(meldung);i++)                /* Meldung im VRAM        */
  74.   *charptr++ = *uc++;                           /* ausgeben               */
  75.  
  76.   if(Channel->actual == 1)                      /* am Bildschirm ebenso   */
  77.   {
  78.    GAttrib = Attrib[1];
  79.    write_(STDOUT,meldung,strlen(meldung));      /* wenn angezeigt         */
  80.    GAttrib = Attrib[0];
  81.   }
  82.  
  83.                                                 /* Ident besetzen         */
  84.   sprintf(Channel->ident,"%s",Channel->call);
  85.  
  86.                                                 /* Kommandozeile besetzen */
  87.   if(isMBCall(Channel->call) == 0)
  88.   {
  89.    if(Channel->SFChannel != 2)
  90.    sprintf(Channel->KomZeile,"%s\r%s de %s>",Channel->MSGS->BoxMSG21,Channel->ident,Channel->OwnCall);
  91.    else
  92.    sprintf(Channel->KomZeile,"\r%s de %s \r+?",Channel->ident,Channel->OwnCall);
  93.   }
  94.   else
  95.   {
  96.    sprintf(Channel->KomZeile,">\r");
  97.    /*send_tnc(1,Channel,"Y0");*/
  98.   }
  99.  
  100.   if(Channel->SFFlag != Off)
  101.   sprintf(Channel->KomZeile,"%c\r",26);
  102.  
  103.  
  104.   if ((Channel->Mailbox == 1)&&(Channel->SFFlag < SFLog))
  105.   {
  106.    Channel->SOffset = Channel->SBuffer;
  107.  
  108.    if((isMBCall(Channel->call)==0)&&(Channel->PrivStatus != 1)&&(Channel->SFChannel == 1))
  109.    {
  110.     buffering(Channel,"\r");
  111.     buffering(Channel,Channel->MSGS->BoxMSG23);
  112.     buffering(Channel,"\r");
  113.     putout(Channel);
  114.     send_tnc(1,Channel,"D");
  115.     Channel->Mailbox = 0;
  116.    }
  117.    else
  118.    {
  119.     Channel->isMBL = 0;
  120.     if(isMBCall(Channel->call)) buffering(Channel,"[MBL-$]\r");
  121.     else
  122.     {
  123.      buffering(Channel,"\r");
  124.      buffering(Channel,Channel->MSGS->BoxMSG24);
  125.      buffering(Channel," ");
  126.      buffering(Channel,Channel->MSGS->BoxMSG25);
  127.      buffering(Channel," ");
  128.      buffering(Channel,DatumUhrzeit);
  129.      if (neu != 1)
  130.      {
  131.       buffering(Channel,Channel->MSGS->BoxMSG28);
  132.       buffering(Channel," ");
  133.       if(*Channel->UsrName != '\0')
  134.       buffering(Channel,Channel->UsrName);
  135.       buffering(Channel,", ");
  136.       buffering(Channel,Channel->MSGS->BoxMSG29);
  137.       buffering(Channel," ");
  138.       buffering(Channel,Channel->LastLogin);
  139.       buffering(Channel," ");
  140.       buffering(Channel,UTC);
  141.       buffering(Channel,"\r");
  142.      }
  143.      if(strlen(Channel->UsrName) == 0)
  144.      {
  145.       buffering(Channel,Channel->MSGS->BoxMSG38);
  146.       buffering(Channel,"\r");
  147.      }
  148.      if(strlen(mybbs) == 0)
  149.      {
  150.       buffering(Channel,Channel->MSGS->BoxMSG39);
  151.       buffering(Channel,"\r");
  152.      }
  153.  
  154.      if(Channel->SFChannel != 2)
  155.      sprintf(ChanStr,"%sSTART.%s",Prefix->Prefix3,Channel->MSGS->ID);
  156.      else
  157.      sprintf(ChanStr,"%sSTARTAMT.%s",Prefix->Prefix3,Channel->MSGS->ID);
  158.      chan = open_(ChanStr,"R");
  159.      if(chan != -1)
  160.      {
  161.       _setmem(dummy,256,0);
  162.       read_(chan,dummy,255);
  163.       close_(chan);
  164.       cc = dummy;
  165.       while((*cc != '\0') && (*cc != '\032')) cc++;
  166.       *cc = '\0';
  167.       buffering(Channel,dummy);
  168.       buffering(Channel,"\r\r");
  169.      }
  170.      else
  171.      buffering(Channel,"\r");
  172.  
  173.      sprintf(ChanStr,"%s%s.AMT",Prefix->Prefix1,Channel->call);
  174.      LogChannel = open_(ChanStr,"R");
  175.      if(LogChannel != -1)
  176.      {
  177.       buffering(Channel,Channel->MSGS->BoxMSG26);
  178.       buffering(Channel,":\r");
  179.       close_(LogChannel);
  180.       putout(Channel);
  181.       sprintf(Channel->Response,"L %s 1-\r",Channel->call);
  182.       interpre(Channel);
  183.      }
  184.      else
  185.      {
  186.       buffering(Channel,Channel->MSGS->BoxMSG27);
  187.       buffering(Channel,"\r\r");
  188.      }
  189.  
  190.     }
  191.  
  192.     scom(Channel);
  193.     Channel->RecStatus = Off;
  194.     Channel->Import = 0;
  195.    }
  196.   }
  197.  
  198.  
  199.   sprintf(ChanStr,"%sPACK.LOG",Prefix->Prefix3);
  200.                                                 /* Warten bis Log offen   */
  201.   while((LogChannel = open_(ChanStr,"A")) == -1);
  202.  
  203.   PosEnd(LogChannel);
  204.  
  205.    Channel->LogPos = tell_(LogChannel) ;        /* LogPos merken          */
  206.    *(DatumUhrzeit+8) = '\0';                    /* Dat-Uhr in zwei strings*/
  207.    *(DatumUhrzeit+14)= '\0';                    /* zerteilen              */
  208.  
  209.    Channel->Score = 0L;
  210.  
  211.    sprintf(Channel->LogZeile,                   /* Logzeile machen        */
  212.            "%-6s  %6s  %5s - %5s %s %d        %s\r\n",
  213.            Channel->call,
  214.            DatumUhrzeit,
  215.            DatumUhrzeit+9,
  216.            "??:??",
  217.            UTC,
  218.            Channel->Log_Chan,
  219.            LgStr);
  220.  
  221.    write_(LogChannel,
  222.           Channel->LogZeile,
  223.           strlen(Channel->LogZeile));           /* schreiben              */
  224.  
  225.    close_(LogChannel);                          /* schliessen             */
  226.  
  227.    Channel->connected = 1;                      /* Als connected merken   */
  228.    show_con();
  229.    SetCursor(Channel);
  230.    Channel->TimeOut   = time_();                /* Tiemout triggern       */
  231.    _setmem(Channel->comstack,256,0);
  232.  
  233.    if(Channel->SFFlag == SFLog) SFWork(Channel);
  234.  }
  235.  else
  236.  send_tnc(1,Channel,"D");
  237. }
  238.  
  239. logout(Channel)
  240. /*------------------------------------------------------------------------*/
  241. /* Funktion : Ueberschreibt den vorher gemachten Logeintrag im Log mit    */
  242. /*            den gemerkten Daten vom Login, sowie der neuen Uhrzeit      */
  243. /*            Weiterhin werden merken ueber Retry/Kontingent/Timeout      */
  244. /*            in die Logzeile eingearbeitet                               */
  245. /* Uebergabe: Pointer auf logische Kanalstruktur                          */
  246. /* Retour   : nichts                                                      */
  247. /*------------------------------------------------------------------------*/
  248. struct header *Channel;
  249. {
  250.   int LogChannel;
  251.   char ChanStr[80];
  252.   char DatumUhrzeit[25];
  253.   int  i;
  254.   char meldung[81];
  255.   unsigned char *uc;
  256.   char CharScore[80];
  257.  
  258.     sprintf(ChanStr,"%sPACK.LOG",Prefix->Prefix3);
  259.                                                 /* Warten bis Log offen   */
  260.     while((LogChannel = open_(ChanStr,"A")) == -1);
  261.     {
  262.      uhrzeitlesen(DatumUhrzeit);                /* Endezeit               */
  263.      *(DatumUhrzeit + 14) = '\0';               /* Datum kappen           */
  264.  
  265.                                                 /* in Logzeile bringen    */
  266.      _move(5,DatumUhrzeit+9,Channel->LogZeile+26);
  267.  
  268.      sprintf(CharScore,"%6ld",Channel->Score);
  269.      _move(6,CharScore,Channel->LogZeile+ 38);
  270.  
  271.                                                 /* Stelle im Log suchen   */
  272.      seek_(LogChannel,Channel->LogPos,0);       /* seeken                 */
  273.  
  274.      write_(LogChannel,
  275.             Channel->LogZeile,
  276.             strlen(Channel->LogZeile)
  277.            );                                   /* schreiben              */
  278.  
  279.      close_(LogChannel);                        /* schliessen             */
  280.  
  281.      _setmem(meldung,40,196);                   /* meldung mit '_'        */
  282.      *(meldung + 40) = '\0';                            /* versehen               */
  283.  
  284.      uc = Channel->VRAM + 440;
  285.      for(i=0;i<strlen(meldung);i++)             /* im VRAM ausgeben       */
  286.      *uc++ =  ' ';
  287.  
  288.      if(Channel->actual == 1)                   /* wenn angezeigt dann    */
  289.      {
  290.       gotoxy(41,6);                             /* ausgeben               */
  291.       GAttrib = Attrib[1];
  292.       write_(STDOUT,meldung,40);                /* ausgeben (Bildschirm)  */
  293.       GAttrib = Attrib[0];
  294.      }
  295.  
  296.      Channel->connected = 0;                    /* Disconnected merken    */
  297.      Channel->SendStatus= Off;
  298.      Channel->RecStatus = Off;
  299.      Channel->Mailbox   = 1;
  300.      Channel->sysinp    = 0;
  301.      Channel->SFPos     = 1L;
  302.      Channel->Import    = 0;
  303.  
  304.      if(Channel->actual == 1)
  305.      {
  306.       gotoxy(27,1);printf("MAILBOX ");
  307.      }
  308.      CloseAll(Channel);
  309.     }
  310.    show_con();
  311.    Channel->SOffset = Channel->SBuffer;
  312. }
  313.  
  314. logread(Channel,ID)
  315. /*------------------------------------------------------------------------*/
  316. /* Funktion : Reaktion auf das Box-Kommando 'Log'                         */
  317. /*            Positioniert 800 Bytes vor das Ende des Logs und liest      */
  318. /*            ab dem naechsten LF in Channel->Response ein.               */
  319. /* Uebergabe: Pointer auf logische Kanalstruktur                          */
  320. /* Retour   : nichts                                                      */
  321. /*------------------------------------------------------------------------*/
  322. struct header *Channel;
  323. char ID;
  324. {
  325.   file LogChannel;
  326.   char ChanStr[80];
  327.   int  Anzahl;
  328.  
  329.     if (ID == 'P')
  330.     sprintf(ChanStr,"%sPACK.LOG",Prefix->Prefix3);
  331.     else
  332.     sprintf(ChanStr,"%sAMT.LOG",Prefix->Prefix3);
  333.                                                 /* Warten bis Log offen   */
  334.     while((LogChannel = open_(ChanStr,"A")) == -1);
  335.     {
  336.  
  337.      seek_(LogChannel,-800L,2);
  338.  
  339.      Channel->SOffset = Channel->SBuffer;       /* Buffer vorbereiten     */
  340.      buffering(Channel,"\r\r");
  341.  
  342.      while(get_(LogChannel) != 10);             /* hinter LF positionieren*/
  343.  
  344.                                                 /* Rest des Logs lesen    */
  345.      Anzahl = read_(LogChannel,Channel->SOffset,1000);
  346.  
  347.      close_(LogChannel);                        /* schliessen             */
  348.  
  349.      Channel->SOffset += Anzahl;                /* Endepointer aktual.    */
  350.  
  351.      *(Channel->SOffset++) = '\015';            /* Cr anfuegen            */
  352.  
  353.      scom(Channel);                             /* ausgabe anstossen      */
  354.     }
  355. }
  356.  
  357.  
  358. getIndex(Index,call)
  359. struct userindex *Index;
  360. char *call;
  361. {
  362.  int i,found,IFile;
  363.  struct userindex *USRIDX;
  364.  char dummycall[10], *c, ChanStr[80];
  365.  int Count,Menge;
  366.  
  367.  
  368.  sprintf(dummycall,"%-6.6s",call);
  369.  USRIDX = IndexArray;
  370.  found  = 0;
  371.  Menge  = 12000;
  372.  
  373.  for(i=0 ; (i < 1000) && (found == 0) ; i++, USRIDX++)
  374.  {
  375.   Menge -= 12;
  376.   if(strncmp(dummycall,IndexArray[i].call,6) == 0)
  377.   {
  378.    sprintf(Index->call,"%-6.6s",IndexArray[i].call);
  379.    Index->pos  = IndexArray[i].pos ;
  380.    found = 1;
  381.    if(Menge > 0)
  382.    {
  383.     _move(Menge,&IndexArray[i+1],&IndexArray[i]);
  384.     _setmem(&IndexArray[999],12,0);
  385.    }
  386.   }
  387.  }
  388.  
  389.  if(found == 0)
  390.  {
  391.   sprintf(ChanStr,"%sUSER3.IDX",Prefix->Prefix3);
  392.   IFile = open_(ChanStr,"R");
  393.   if(IFile != -1)
  394.   {
  395.    do
  396.    {
  397.     Menge = read_(IFile,MultiBuff,10200);
  398.     Count = Menge;
  399.     if(Menge >= 12)
  400.     {
  401.      c = MultiBuff;
  402.      while((Count > 0) && (found == 0))
  403.      {
  404.       if(strncmp(c,dummycall,6) == 0)
  405.       {
  406.        found = 1;
  407.        USRIDX = (struct userindex *)c;
  408.        sprintf(Index->call,"%-6.6s",USRIDX->call);
  409.        Index->pos = USRIDX->pos;
  410.       }
  411.       c += 12;
  412.       Count += 12;
  413.      }
  414.     }
  415.    }
  416.    while((found == 0) && (Menge == 10200));
  417.    close_(IFile);
  418.   }
  419.  }
  420.  return(found);
  421. }
  422.  
  423.  
  424. putIndex(Index)
  425. struct userindex *Index;
  426. {
  427.  _move(11988,&IndexArray[0],&IndexArray[1]);
  428.  sprintf(IndexArray[0].call,"%s",Index->call);
  429.  IndexArray[0].pos = Index->pos;
  430. }
  431.  
  432.  
  433. saveIndex(Index,Record)
  434. struct userindex  *Index  ;
  435. struct userrec    *Record ;
  436. {
  437.  int UserFile,User1File;
  438.  char ChanStr[80],ChanStr1[80];
  439.  long tell_();
  440.  
  441.  sprintf(ChanStr,"%sUSER3.IDX",Prefix->Prefix3);
  442.  sprintf(ChanStr1,"%sUSER3.DAT",Prefix->Prefix3);
  443.  
  444.  do
  445.   UserFile = open_(ChanStr,"A");
  446.  while(UserFile == -1);
  447.  
  448.  do
  449.   User1File = open_(ChanStr1,"A");
  450.  while(User1File == -1);
  451.  
  452.  Index->pos = tell_(User1File);
  453.  
  454.  write_(User1File,Record,sizeof(struct userrec));
  455.  
  456.  close_(User1File);
  457.  
  458.  
  459.  write_(UserFile,Index,sizeof(struct userindex));
  460.  
  461.  close_(UserFile);
  462.  
  463.  putIndex(Index);
  464. }
  465.  
  466.  
  467. getRecord(Index,Record)
  468. struct userindex *Index;
  469. struct userrec   *Record;
  470. {
  471.  int UserFile;
  472.  char ChanStr[80];
  473.  
  474.  sprintf(ChanStr,"%sUSER3.DAT",Prefix->Prefix3);
  475.  
  476.  do
  477.   UserFile = open_(ChanStr,"R");
  478.  while(UserFile == -1);
  479.  
  480.  seek_(UserFile,Index->pos,0);
  481.  read_(UserFile,Record,sizeof(struct userrec));
  482.  
  483.  close_(UserFile);
  484.  
  485. }
  486.  
  487.  
  488. putRecord(Index,Record)
  489. struct userindex *Index;
  490. struct userrec   *Record;
  491. {
  492.  int UserFile;
  493.  char ChanStr[80];
  494.  
  495.  sprintf(ChanStr,"%sUSER3.DAT",Prefix->Prefix3);
  496.  
  497.  do
  498.   UserFile = open_(ChanStr,"W");
  499.  while(UserFile == -1);
  500.  
  501.  seek_(UserFile,Index->pos,0);
  502.  write_(UserFile,Record,sizeof(struct userrec));
  503.  
  504.  close_(UserFile);
  505.  
  506. }
  507.  
  508. int findUser(Channel,DatumUhrzeit,mybbs)
  509. struct header *Channel;
  510. char *DatumUhrzeit,*mybbs;
  511. {
  512.  struct userindex Index;
  513.  struct userrec   Record;
  514.  int retval;
  515.  int  i;
  516.  char *c;
  517.  char *cc;
  518.  
  519.  if(getIndex(&Index,Channel->call) == 0)
  520.  {
  521.   sprintf(Index.call,"%-6.6s",Channel->call);
  522.   _setmem(&Record,sizeof(struct userrec),0);
  523.   sprintf(Record.LastLogin,"%-14.14s",DatumUhrzeit);
  524.   switch(FirstLang[Channel->Log_Chan])
  525.   {
  526.    case 0:
  527.    case 1: Channel->MSGS = Lang1;
  528.        break;
  529.    case 2: Channel->MSGS = Lang2;
  530.        break;
  531.    case 3: Channel->MSGS = Lang3;
  532.        break;
  533.    case 4: Channel->MSGS = Lang4;
  534.        break;
  535.    case 5: Channel->MSGS = Lang5;
  536.        break;
  537.    case 6: Channel->MSGS = Lang6;
  538.        break;
  539.   }
  540.   sprintf(Record.Language,"%-3.3s",Channel->MSGS->ID);
  541.  
  542.   saveIndex(&Index,&Record);
  543.  
  544.   retval = 1;
  545.  
  546.  }
  547.  
  548.  else
  549.  
  550.  {
  551.   getRecord(&Index,&Record);
  552.  
  553.   sprintf(Channel->LastLogin,"%-14.14s",Record.LastLogin);
  554.  
  555.   sprintf(Record.LastLogin,"%-14.14s",DatumUhrzeit);
  556.  
  557.   putIndex(&Index);
  558.   putRecord(&Index,&Record);
  559.  
  560.   retval = 0;
  561.  }
  562.  
  563.  Channel->MSGS = Lang1;
  564.  for(i=0;i<6;i++)
  565.  {
  566.   switch(i)
  567.   {
  568.    case 0 : if(strncmp(Record.Language,Lang1->ID,3)==0)
  569.         {
  570.          i = 6;
  571.          Channel->MSGS = Lang1;
  572.         }
  573.         break;
  574.    case 1 : if(strncmp(Record.Language,Lang2->ID,3)==0)
  575.         {
  576.          i = 6;
  577.          Channel->MSGS = Lang2;
  578.         }
  579.         break;
  580.    case 2 : if(strncmp(Record.Language,Lang3->ID,3)==0)
  581.         {
  582.          i = 6;
  583.          Channel->MSGS = Lang3;
  584.         }
  585.         break;
  586.    case 3 : if(strncmp(Record.Language,Lang4->ID,3)==0)
  587.         {
  588.          i = 6;
  589.          Channel->MSGS = Lang4;
  590.         }
  591.         break;
  592.    case 4 : if(strncmp(Record.Language,Lang5->ID,3)==0)
  593.         {
  594.          i = 6;
  595.          Channel->MSGS = Lang5;
  596.         }
  597.         break;
  598.    case 5 : if(strncmp(Record.Language,Lang6->ID,3)==0)
  599.         {
  600.          i = 6;
  601.          Channel->MSGS = Lang6;
  602.         }
  603.         break;
  604.   }
  605.  }
  606.  
  607.  sprintf(Channel->UsrName,"%s",Record.Name);
  608.  cc = c = Channel->UsrName;
  609.  *c++ = toupper(*cc++);
  610.  do
  611.  {
  612.   if(isalnum(*(c-1))) *c++ = tolower(*cc++);
  613.   else
  614.   *c++ = toupper(*cc++);
  615.  }
  616.  while(*cc != '\0');
  617.  sprintf(mybbs,Record.MyBBS);
  618.  Channel->PrivStatus = Record.Status;
  619.  
  620.  return(retval);
  621. }
  622.  
  623.  
  624. int initUser()
  625. {
  626.  char ChanStr[80];
  627.  int file1,file2;
  628.  
  629.  sprintf(ChanStr,"%sUSER3.IDX",Prefix->Prefix3);
  630.  file1 = open_(ChanStr,"R");
  631.  if(file1 == -1)
  632.  {
  633.   clrscr();
  634.   printf("USER3.IDX not found\n");
  635.   exit();
  636.  }
  637.  
  638.  sprintf(ChanStr,"%sUSER3.DAT",Prefix->Prefix3);
  639.  file2 = open_(ChanStr,"R");
  640.  if(file2 == -1)
  641.  {
  642.   clrscr();
  643.   printf("USER3.DAT not found\n");
  644.   exit();
  645.  }
  646.  
  647.  close_(file1);
  648.  close_(file2);
  649.  
  650.  _setmem(IndexArray,12000,0);
  651.  
  652.  sprintf(ChanStr,"%sUSERS.BOX",Prefix->Prefix3);
  653.  file1 = open_(ChanStr,"R");
  654.  if(file1 != -1)
  655.  {
  656.   read_(file1,IndexArray,12000);
  657.   close_(file1);
  658.  }
  659.  return(1);
  660. }
  661.  
  662. SaveUser()
  663. {
  664.  int file1;
  665.  char ChanStr[80];
  666.  
  667.  sprintf(ChanStr,"%sUSERS.BOX",Prefix->Prefix3);
  668.  file1 = open_(ChanStr,"W");
  669.  if(file1 == -1)
  670.  file1 = open_(ChanStr,"C");
  671.  if(file1 != -1)
  672.  {
  673.   write_(file1,IndexArray,12000);
  674.   close_(file1);
  675.  }
  676. }
  677.  
  678. int updateUSR(Call,Name,MailBox,Status,Lang,priv)
  679. char *Call,*Name,*MailBox,*Lang;
  680. int priv;
  681. int Status;
  682. {
  683.  struct userindex Index;
  684.  struct userrec   Record;
  685.  int retval;
  686.  char tempcall[7];
  687.  
  688.  sprintf(tempcall,"%-6.6s",Call);
  689.  
  690.  retval = 0;
  691.  
  692.  if(getIndex(&Index,Call) == 1)
  693.  {
  694.   retval = 1;
  695.  
  696.   getRecord(&Index,&Record);
  697.  
  698.   if(strncmp(Name,"      ",6) != 0)
  699.   sprintf(Record.Name,"%s",Name);
  700.  
  701.   if(strncmp(MailBox,"      ",6) != 0)
  702.   sprintf(Record.MyBBS,"%-6.6s",MailBox);
  703.  
  704.   if(strncmp(Lang,"   ",3) != 0)
  705.   sprintf(Record.Language,"%-3.3s",Lang);
  706.  
  707.   if(Status != -1) Record.Status = Status;
  708.  
  709.   putRecord(&Index,&Record);
  710.   putIndex(&Index);
  711.  
  712.  }
  713.  else
  714.  {
  715.   if(priv == 1)
  716.   {
  717.    _setmem(&Record,sizeof(struct userrec),0);
  718.    sprintf(Record.LastLogin,"%-14.14s","  ");
  719.    sprintf(Record.Language,"%-3.3s"," ");
  720.    sprintf(Record.MyBBS,"%-6.6s",MailBox);
  721.    Record.Status = Status;
  722.    sprintf(Index.call,"%-6.6s",tempcall);
  723.  
  724.    retval = 1;
  725.    saveIndex(&Index,&Record);
  726.   }
  727.  }
  728.  return(retval);
  729. }
  730.  
  731. int readUSRInfo(Call,MailBox,LastLogin,OPName,Status,Lang)
  732. char *Call,*MailBox,*LastLogin,*OPName,*Lang;
  733. int *Status;
  734. {
  735.  struct userindex Index;
  736.  struct userrec   Record;
  737.  char tempcall[7];
  738.  
  739.  _setmem(MailBox,7,0);
  740.  
  741.  if(getIndex(&Index,Call) == 1)
  742.  {
  743.  
  744.   getRecord(&Index,&Record);
  745.  
  746.   sprintf(tempcall,"%-6.6s",Record.MyBBS);
  747.   if(strcmp(tempcall,"OwnBBS") != 0)
  748.   sprintf(MailBox,"%s",Record.MyBBS);
  749.  
  750.   sprintf(LastLogin,"%s",Record.LastLogin);
  751.   sprintf(OPName,"%s",Record.Name);
  752.  
  753.   sprintf(Lang,"%-3.3s",Record.Language);
  754.  
  755.   *Status = Record.Status;
  756.  
  757.   putIndex(&Index);
  758.  
  759.   return(1);
  760.  }
  761.  else return(-1);
  762. }
  763.  
  764.